package Advanced;

import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.HashMap;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.BufferedWriter;
import java.io.BufferedReader;

public class demo17缓冲流{

	public static void main(String[] args) throws IOException {
//		bufferedOutputStream();
//		bufferedInputStream();
//		fileCopyOfBuffered();
//		BufferedWriter();
//		BufferedReader();
		textSort();
		   
	}
	public static void bufferedOutputStream() throws IOException {
		/* java.io.BufferedOutputStream extends OutputStream
		 * BufferedOutputStream:字节缓冲输出流
		 * 
		 * 继承自父类的共性成员方法：
		 * 		public void close()：关闭此输出流并释放与此相关联的任何系统资源
		 * 		public void flush()：刷新此输出流并强制任何缓冲的输出字节被写出
		 * 		public void write(byte[] b)：将b.length字节从指定的字节数组写入此输出流
		 * 		public void write(byte[] b,int off,int len) ：从指定的字节数组写入len字节，从偏移量off开始输入到此输出流
		 * 		public abstract void write(int b)：将指定的字节写入此输出流
		 * 构造方法：
		 * 		BufferedOutputStream(OutputStream out) 创建一个新的缓冲输出流，以将数据写入指定的底层输出流
		 * 		BufferedOutputStream(outputStream out,int size) 创建一个新的缓冲输出流，以将具有指定缓冲区大小的数据写入指定的底层输出流
		 * 		参数：
		 * 			OutputStream out:字节输出流
		 * 
		 * */
		FileOutputStream fos = new FileOutputStream("D:\\下载\\asbd\\c.txt");
		BufferedOutputStream bos = new BufferedOutputStream(fos);
		bos.write("水电费规划局电风扇".getBytes());
		
		bos.close();
	}
	public static void bufferedInputStream() throws IOException {
		/* java.io.BufferedInputStream extends InputStream
		 * BufferedInputStream:字节缓冲输入流
		 * 
		 * 继承自父类的成员方法：
		 * 		int read()从输入流中读取数据的下一个字节,读取到文件的末尾返回-1
		 * 		int read(byte[] b)从输入流中读取一定数量的字节，并将其储存在缓冲区数组b中
		 * 		void close()关闭此输入流并释放与该相关联的所有系统资源
		 * 构造方法：
		 * 		BufferedInputStream(InputStream in) 
		 * 		BufferedInputStream(InputStream in,int size) 
		 * 		
		 * */
		FileInputStream fis = new FileInputStream("D:\\锟斤拷锟斤拷\\asbd\\c.txt");
		BufferedInputStream bis = new BufferedInputStream(fis);
		int len = 0;
		while((len = bis.read()) != -1) {
			System.out.println(len);
		}
		bis.close();
	}
	public static void fileCopyOfBuffered() throws IOException {
		long s = System.currentTimeMillis();
		
		FileInputStream fis = new FileInputStream("C:\\Users\\ASUS\\Downloads\\1.png");
		FileOutputStream fos = new FileOutputStream("D:\\下载\\asbd\\1.png");
		BufferedInputStream bis = new BufferedInputStream(fis);
		BufferedOutputStream bos = new BufferedOutputStream(fos);
		
//		int len = 0;
//		while((len = bis.read()) != -1) {
//			bos.write(len);
//		}
		
		byte[] bytes = new byte[1024];
		int len = 0;
		while((len = bis.read(bytes)) != -1) {
			bos.write(bytes,0,len);
		}
		
		bos.close();
		bis.close();
		long e = System.currentTimeMillis();
		System.out.println("需要的时间" + (e - s) + "毫秒");
		//先关写再关读
	}
	public static void BufferedWriter() throws IOException {
		/* java.io.BufferedWriter extends Writer
		 * 
		 * 继承自父类的共性成员方法
		 * 		void write(int c) 写入单个字符
		 * 		void write(char[] cbuf) 写入字符数组
		 * 		abstract void write(char[] cbuf,int off,int len) 写入字符数组的一部分
		 * 		void write(String str) 写入字符串
		 * 		void write(String str,int off, int len) 写入字符串的一部分
		 * 		void flush() 刷新该流的缓冲
		 * 		void close() 关闭该流，但要先刷新它

		 * 构造方法：
		 * 		BufferedWriter(Writer out) 
		 * 		BufferedWriter(Writer out,int size) 
		 * 
		 * 特有的成员方法：
		 * 		void newLine() 
		 * */
		BufferedWriter bw = new BufferedWriter(new FileWriter("D:\\锟斤拷锟斤拷\\asbd\\c.txt"));
		for(int i = 0;i < 10;i++) {
			bw.write("锟斤拷锟斤拷一锟斤拷锟斤拷帅锟斤拷" );
			bw.newLine();
		}
		
		bw.close();
	}
	public static void BufferedReader() throws IOException {
		/* java.io.BufferedReader extends Reader
		 * BufferedReader:字符缓冲输入流
		 * 
		 * 继承自父类的共性成员方法：
		 * 		int read() 读取单个字符并返回
		 * 		int read(char[] cbuf) 一次读取多个字符，将字符读入数组
		 * 		void close() 关闭该流并释放与之相关联的所有资源
		 * 构造方法：
		 * 		BufferedReader(Reader in) 
		 * 		BufferedReader(Reader in,int size) 
		 * 特有的成员方法：
		 * 		String readLine() 读取一个文本行
		 * 			行的终止符号，通过下列字符之一即可认为某行已经终止：换行('\n')、回车('\r')或者回车后直接跟着换行('\r\n')
		 * 		返回值：
		 * 			包含该行内容的字符串，不包含任何的终止符，如果已经到达流的末尾，则返回null
		 * */
		BufferedReader br = new BufferedReader(new FileReader("D:\\下载\\asbd\\c.txt"));
		String str = new String();
		while((str = br.readLine()) != null) {
			System.out.println(str);
		}
		System.out.println(str);
		br.close();
	}
	public static void textSort() throws IOException {
		//文件排序
//		BufferedReader br = new BufferedReader(new FileReader("D:\\下载\\asbd\\a.txt"));
//		Properties prop = new Properties();
//		HashMap<Integer, String> map = new HashMap<Integer, String>();
//		String line = new String();
//		while((line = br.readLine()) != null) {
//			String lineEnd = line.replace(".","=");
//			prop.setProperty(lineEnd.substring(0, 1),lineEnd.substring(2));
//			
//		}
//		Set<String> set = prop.stringPropertyNames();
//		
//		for(String key : set) {
//			int keyEnd = Integer.valueOf(key);
//			map.put(keyEnd,prop.getProperty(key));
//		}
//		
//		ArrayList<Integer> list = new ArrayList<>();
//		Set<Integer> setNum = map.keySet();
//		for(int i : setNum) {
//			list.add(i);
//		}
//		
//		Collections.sort(list);
//		HashMap<Integer, String> mapEnd = new HashMap<Integer, String>();
//		for(int i :list) {
//			mapEnd.put(i,map.get(i));
//		}
//		
//		Properties propEnd = new Properties();
//		for(int i : list) {
//			propEnd.setProperty("i", mapEnd.get(i));
//		}
//		
//		BufferedWriter bw = new BufferedWriter(new FileWriter("D:\\涓嬭浇\\asbd\\b.txt"));
//		propEnd.store(bw,"save data");
//		
//		bw.close();
//		br.close();
//		
		
		HashMap<String, String> map = new HashMap<String, String>();
		BufferedReader br = new BufferedReader(new FileReader("D:\\下载\\asbd\\a.txt"));
		BufferedWriter bw = new BufferedWriter(new FileWriter("D:\\下载\\asbd\\b.txt"));
		
		String line = new String();
		while((line = br.readLine()) != null) {
			String[] arr = line.split("\\.");
			map.put(arr[0],arr[1]);
		}
		
		for(String key : map.keySet()) {
			String value = map.get(key);
			line = key + "." + value;
			bw.write(line);
			bw.newLine();
		}
		
		bw.close();
		br.close();
	}
}
